/**
 * 串行执行异步任务，支持失败重试
 * @param {Function[]} tasks 异步任务函数数组
 * @param {number} retries 最大重试次数
 * @return {Promise<any[]>} promise 返回值为所有任务结果的数组
 */
// function executeTasks(tasks = [], retries = 0) {
//     const result = [];

//     // 执行单个任务并处理重试
//     async function executeWithRetry(taskFn, currentRetries = 0) {
//         try {
//             // 尝试执行任务
//             const res = await taskFn();
//             return res;
//         } catch (error) {
//             // 如果还有重试次数，递归重试
//             if (currentRetries < retries) {
//                 return executeWithRetry(taskFn, currentRetries + 1);
//             }
//             // 重试次数用完，抛出错误
//             throw error;
//         }
//     }

//     // 串行执行所有任务
//     async function executeSequentially() {
//         for (const taskFn of tasks) {
//             // 执行当前任务并等待完成
//             const res = await executeWithRetry(taskFn);
//             // 将结果添加到结果数组
//             result.push(res);
//         }
//         // 所有任务执行完毕，返回结果数组
//         return result;
//     }

//     // 返回一个Promise
//     return executeSequentially();
// }

// 测试代码


/**
 * 串行执行异步任务，每个任务失败时会进行重试
 * @param {Function[]} tasks 异步任务函数数组
 * @param {number} retries 最大重试次数
 * @return {Promise<any[]>} promise 返回值为所有任务结果的数组
 */
//迭代器方法
function executeTasks(tasks = [], retries = 0) {
    // 辅助函数：执行单个任务并处理重试
    const executeTaskWithRetry = async (task, remainingRetries) => {
        try {
            // 尝试执行任务
            return await task();
        } catch (error) {
            // 如果还有重试次数，递归重试
            if (remainingRetries > 0) {
                return executeTaskWithRetry(task, remainingRetries - 1);
            }
            // 没有重试次数了，抛出最后一次错误
            throw error;
        }
    };

    // 使用Promise包装整个执行过程
    return new Promise((resolve, reject) => {
        const results = [];
        // 获取任务数组的迭代器
        const taskIterator = tasks[Symbol.iterator]();

        // 处理下一个任务的函数
        const processNextTask = async () => {
            // 获取迭代器的下一个任务
            const { value: currentTask, done } = taskIterator.next();

            // 如果所有任务都执行完毕，返回结果数组
            if (done) {
                resolve(results);
                return;
            }

            try {
                // 执行当前任务并处理重试
                const result = await executeTaskWithRetry(currentTask, retries);
                results.push(result);
                // 继续处理下一个任务
                processNextTask();
            } catch (error) {
                // 如果任务最终失败，整体拒绝
                reject(error);
            }
        };

        // 开始执行第一个任务
        processNextTask();
    });
}

const makeTask = (index) => {
    return () => {
        return new Promise((resolve, reject) => {
            return setTimeout(() => {
                return Math.random() > 0.5 ? resolve(`task ${index} success`) : reject(new Error(`task ${index} failed`));
            }, 1000);
        });
    };
};
const tasks = [
    makeTask(0),
    makeTask(1),
    // 可继续添加任务
];

async function test() {
    try {
        const res = await executeTasks(tasks, 2);
        console.log('所有任务执行完成', res);
    } catch (err) {
        console.log('任务执行失败', err);
    }
}

// 调用测试函数
test();